package com.googlecode.kipler.satisfiability.completion.rule.individual;

import com.googlecode.kipler.container.dl.ConceptCategory;
import com.googlecode.kipler.container.dl.Individual;
import com.googlecode.kipler.container.dl.World;
import com.googlecode.kipler.container.dl.WorldConstraintSystem;
import com.googlecode.kipler.satisfiability.blocking.abox.ABoxBlockingStrategy;
import com.googlecode.kipler.satisfiability.completion.rule.individual.uniformnotation.BeforeAlphaConcept;
import com.googlecode.kipler.satisfiability.reasoner.ReasonerException;


public class BeforeConceptRule extends ABoxRule {

	private AlphaConceptRule alphaRule;

	public BeforeConceptRule(ABoxBlockingStrategy blocking) {
		alphaRule = new AlphaConceptRule(blocking, ConceptCategory.BEFORE,
				new BeforeAlphaConcept(), "Before concept rule");
	}

	@Override
	public void apply() throws ReasonerException {
		alphaRule.apply();
	}

	@Override
	public boolean isApplied() {
		return alphaRule.isApplied();
	}

	public ABoxBlockingStrategy getBlocking() {
		return alphaRule.getBlocking();
	}

	public Individual getIndividual() {
		return alphaRule.getIndividual();
	}

	public WorldConstraintSystem getWcs() {
		return alphaRule.getWcs();
	}

	public World getWorld() {
		return alphaRule.getWorld();
	}

	public void setBlocking(ABoxBlockingStrategy blocking) {
		alphaRule.setBlocking(blocking);
	}

	public void setIndividual(Individual individual) {
		alphaRule.setIndividual(individual);
	}

	public void setWcs(WorldConstraintSystem wcs) {
		alphaRule.setWcs(wcs);
	}

	public void setWorld(World world) {
		alphaRule.setWorld(world);
	}
	
	

}
